package reconnaissance;

import librairies.dictionnaire.interfaces.IDictionnaire;
import librairies.liste.interfaces.IListe;
import librairies.liste.interfaces.IListeE;
import modele.Mot;
import reconnaissance.traitement.impl.TraitementCalcule;
import reconnaissance.traitement.impl.TraitementCopie;
import reconnaissance.traitement.impl.TraitementExecution;
import reconnaissance.traitement.impl.TraitementOuverture;
import reconnaissance.traitement.impl.TraitementRecherche;
import reconnaissance.traitement.interfaces.ITraitement;
import utils.StringUtils;

import commande.Outils;

import enumeration.type.ETypeAction;

/**
 * permet de decomposer une phrase et d'en comprendre le sens.
 * 
 * @author mlozach
 */
public class Reconnaissance 
{
	private IListeE<String> termes;
	private IDictionnaire<Mot> dico;
	private ITraitement traitement;
	private Outils outils;
	private int posAction;
	
	/**
	 * constructeur par defaut.
	 * decompose la phrase en liste de terme.
	 * charge le dico.
	 * lance la comprehension.
	 * 
	 * @param phrase la phrase a reconnaitre.
	 */
	public Reconnaissance(String phrase)
	{	
		this.outils = Outils.getInstance();
		remplirDico();
		
		start(phrase);
	}
	
	public boolean start(String phrase)
	{
		this.posAction = 0;

		chargerTerme(phrase);
		return compherension();
	}

	/**
	 * lance le traitement de la requete
	 * @return <true> si tous c'est bien passé
	 */
	private boolean compherension()
	{
		ETypeAction action = rechercheAction();
		
		if(action == null) 
		{
			return false;
		}
		
		switch(action)
		{
			case CALCULE :
				this.traitement = new TraitementCalcule();
				break;
			case COPIE :
				this.traitement = new TraitementCopie();
				break;
			case EXECUTER :
				this.traitement = new TraitementExecution();
				break;
			case OUVERTURE :
				this.traitement = new TraitementOuverture();
				break;
			case RECHERCHE :
				this.traitement = new TraitementRecherche();
				break;
		}
		
		this.traitement.setListe(this.termes);
		this.traitement.setPositionAction(this.posAction);
		return this.traitement.traitement();
	}
	
	/**
	 * permet de rechercher l'action defini dans la requete
	 * @return le type d'action
	 */
	private ETypeAction rechercheAction()
	{
		if(this.termes == null || this.dico == null) return null;
		
		for(int i = 0; i < this.termes.size(); ++i)
		{
			IListe<Mot> commonPrefix = this.dico.contains(new Mot(this.termes.get(i), ""));
			if(commonPrefix != null && commonPrefix.size() != 0)
			{
				this.posAction = i;
				for(int j = 0; j < commonPrefix.size(); ++j)
				{
					if(ETypeAction.CALCULE.getValue().equals(commonPrefix.get(j).getProvenance())) return ETypeAction.CALCULE;
					else if(ETypeAction.COPIE.getValue().equals(commonPrefix.get(j).getProvenance())) return ETypeAction.COPIE;
					else if(ETypeAction.EXECUTER.getValue().equals(commonPrefix.get(j).getProvenance())) return ETypeAction.EXECUTER;
					else if(ETypeAction.OUVERTURE.getValue().equals(commonPrefix.get(j).getProvenance())) return ETypeAction.OUVERTURE;
					else if(ETypeAction.RECHERCHE.getValue().equals(commonPrefix.get(j).getProvenance())) return ETypeAction.RECHERCHE;
				}
			}
		}
		return null;
	}
	
	/**
	 * permet de diviser la phrase en liste de termes
	 * @param phrase
	 */
	private void chargerTerme(String phrase)
	{
		this.termes = StringUtils.chargementList(phrase);
	}
	
	/**
	 * permet de remplir le dictionnaire avec la comprehension.
	 */
	private void remplirDico() 
	{
		this.dico = this.outils.getComprehensionDico();
	}
}
